package com.liner.homework;

/**
 * 1. 变量的练习：声明、初始化、使用、命名
 * 2. 基本数据类型的练习：int、long、double、boolean、char
 * 3. 类型间的转换：两种方式、两点规则
 */
public class Homework {
    public static void main(String[] args) {
        /*
        *1. 变量的练习：
       - 声明一个变量，一次声明多个变量。
       - 声明变量直接初始化，先声明变量，而后再给变量初始化。
       - 声明整型变量g，声明另一个整型变量h并赋值为g+10，输出变量h的值。

       - 在g本身基础之上增10，输出变量g的值。
       - 声明一些正确的和错误的变量名。
        */

        //声明一个变量，一次声明多个变量。
        int a;
        int b, c, d;
        //声明变量直接初始化，先声明变量，而后再给变量初始化。
        int e = 10;
        int f;
        f = 10;
        //声明整型变量g，声明另一个整型变量h并赋值为g+10，输出变量h的值。
        int g = 10;
        int h = g + 10;
        System.out.println(h);
        //在g本身基础之上增10，输出变量g的值。
        g += 10;
        System.out.println(g);
        //声明一些正确的和错误的变量名。
        int $_12, _$0sd, asd$_ds;
        int zheshigebianliang, 这是个变量;    //命名正确但不建议
        double money, foodPrice; //变量命名遵循小驼峰
        //错误变量名   int 123@#￥asd  不能有除了 $、_ 和字母数字外的符号用来命名变量名，且数字不能开头


        /*
        * 2. 基本数据类型的练习：int

       - 声明初始化两个以上整数变量，并且输出两个整数变量的除法结果
       - 声明两个很大的变量，然后相加，输出运算结果，测试运算溢出现象
        *
        * */

        //声明初始化两个以上整数变量，并且输出两个整数变量的除法结果
        int aa = 1000;
        int bb = 20;
        int cc = 20;
        int dd = aa / bb;
        System.out.println("dd = " + dd);
        int oo = dd / cc;
        System.out.println("oo = " + oo);

        //声明两个很大的变量，然后相加，输出运算结果，测试运算溢出现象
        int ee = 2100000000;
        int ff = 2000000000;
        int gg = ff + ee;
        System.out.println("gg = " + gg); //溢出,最大值和最小值是连接在一起的，当结果超过最大值后，会紧跟着指向最小值


        /*
        3. 基本数据类型的练习：long

       - 声明初始化两个以上的长整型变量
       - 声明变量存储几个较大数据的运算，演示：若有可能溢出建议将L设计在第1个数字后。
        *
        * */

        //声明初始化两个以上的长整型变量
        // long l1 = 10000000000;  10000000000 超过 整型直接量最大值,转换长整型要加 L
        long l1 = 10000000000L;
        long l2 = 2000000000;       //涉及到自动类型转换,将整型自动转为长整型，前提是不要超出整型范围，  -2^31~2^31-1
        long l3 = 3000000000L;
        //声明变量存储几个较大数据的运算，演示：若有可能溢出建议将L设计在第1个数字后。
        long l4 = 1000000000 * 10;
        long l5 = 1000000000L * 10;
        System.out.println("l4 = " + l4);
        System.out.println("l5 = " + l5);


        /*
        *
        * 4. 基本数据类型的练习：double

       - 声明初始化两个以上的浮点型变量
       - 声明几个浮点型变量并将它们做数学操作，演示double运算的舍入误差问题

        * */
        //声明初始化两个以上的浮点型变量
        double d1 = 12.3413;
        double d2 = 421.123456789123456789;
        double dd2 = 1231231.123456789123456789;
        double d3 = 1542.34576465;
        //double 的位数 64位（8*8） float 的位数 32位（4*8）
        float f1 = 16542.123456789f;
        float f2 = 123.138194103120310f;
        System.out.println(d1 + "\t" + d2 + "\t" + d3 + "\t" + dd2 + "\t" + f1 + "\t" + f2);

        double d4 = 4.01;
        double d5 = 1.11;
        System.out.println(d4 - d5); //结果为 2.8999999999999995  这就是舍入偏差，当运用在财务方面的业务时，不用基本数据类型的double
        //在财务方面使用  BigDecimal


        /*
        5. 基本数据类型的练习：boolean

       - 声明初始化两个以上的布尔型变量
        *
        * */

        //声明初始化两个以上的布尔型变量
        boolean b1 = true;
        boolean b2 = false;
        // boolean b3 = 0;    boolean 只有两个值  true 和 false

        /*
        *
        6. 基本数据类型的练习：char

       - 声明初始化五个以上的字符型变量
       - 声明字符型变量，演示转义符

        * */

        //声明初始化五个以上的字符型变量
        char c1 = 'a';
        char c2 = 'o';
        char c3 = 69;
        char c4 = 98;
        char c5 = 48;
        System.out.println(c1 + "\t" + c2 + "\t" + c3 + "\t" + c4 + "\t" + c5);
        //声明字符型变量，演示转义符
        char c6 = '\t';
        char c7 = '\n';
        char c8 = '\r';
        char c9 = '\\';
        char c10 = '\'';

        System.out.println(c6 + "\t" + c7 + "\t" + c8 + "\t" + c9 + "\t" + c10);


        /*
        7. 基本数据类型的转换：两种方式

       - 声明几个变量，演示自动类型转换和强制类型转换的语法
       - 声明一个较大类型的长整型变量，演示强转可能会发生的溢出问题
       - 声明一个较大精度的浮点型变量，演示强转可能会发生的丢失精度问题

        *
        * */

        //声明几个变量，演示自动类型转换和强制类型转换的语法
        byte i1 = 23;
        int i2 = i1;
        System.out.println(i2);

        int i3 = 123;
        short i4 = (short) i3;
        System.out.println(i4);
        //声明一个较大类型的长整型变量，演示强转可能会发生的溢出问题
        long ll = 2100000000000L;
        int ii = (int) ll;
        System.out.println(ii);
        //声明一个较大精度的浮点型变量，演示强转可能会发生的丢失精度问题
        double d12 = 123.43141967646243;
        float f12 = (float) d12;
        System.out.println(f12);


        /*
        8. 基本数据类型的转换：两点规则

       - 声明两个byte型变量b1和b2，并赋值为直接量
       - 声明一个byte型变量，并赋值为b1与b2的和
        *
        * */

        //声明两个byte型变量b1和b2，并赋值为直接量
        byte bb1 = 12;
        byte bb2 = 16;

        //声明一个byte型变量，并赋值为b1与b2的和
        byte bb3 = (byte) (bb1 + bb2);
        System.out.println(bb3);
    }


}
